home *** CD-ROM | disk | FTP | other *** search
/ Revolution - Das Atari CD Magazin 1997 / Revolution - Das Atari CD Magazin 1.iso / software / anwendng / qed_397 / sourcen / ausgabe.c next >
C/C++ Source or Header  |  1997-01-07  |  23KB  |  1,089 lines
  1. #include "global.h"
  2. #include "fontsel.h"
  3. #include "rsc.h"
  4. #include "scroll.h"        /* COPYB */
  5. #include "ausgabe.h"
  6.  
  7. #define BLKANF        1
  8. #define BLKEND        2
  9. #define BLKFULL    4
  10.  
  11. /* lokale Variablen ********************************************************/
  12. LOCAL UBYTE    text[260];
  13. LOCAL WORD    w_text[260];
  14.  
  15. /*!! Muessen am Anfang jeder Routine gesetzt werden !!*/
  16. LOCAL BOOLEAN    tab;
  17. LOCAL WORD        tab_size;
  18. LOCAL BOOLEAN    umbrechen;
  19. LOCAL    BOOLEAN    show_end;
  20.  
  21. /* lokale Prototypen *******************************************************/
  22. LOCAL WORD    w_line_to_str    (LINEP a, WORD *t);
  23. LOCAL WORD    line_to_str        (LINEP a, UBYTE text[]);
  24.  
  25.  
  26. EXTERN VDIPB    VDI_pb;
  27.  
  28.  
  29. LOCAL VOID V_gtext(WORD x, WORD y, WORD *ptr, WORD anz)
  30. {
  31.     _VDIParBlk.ptsin[0] = x;
  32.     _VDIParBlk.ptsin[1] = y;
  33.     _VDIParBlk.contrl[0] = 8;
  34.     _VDIParBlk.contrl[1] = 1;
  35.     _VDIParBlk.contrl[3] = anz;
  36.     _VDIParBlk.contrl[6] = vdi_handle;
  37.     COPYW(_VDIParBlk.intin, ptr, anz*2);
  38.     vdi(&VDI_pb);
  39. }
  40.  
  41. LOCAL WORD Vqt_extent(WORD *ptr, WORD anz)
  42. {
  43.     WORD w;
  44.  
  45.     _VDIParBlk.contrl[0] = 116;
  46.     _VDIParBlk.contrl[1] = 0;
  47.     _VDIParBlk.contrl[3] = anz;
  48.     _VDIParBlk.contrl[6] = vdi_handle;
  49.     COPYW(_VDIParBlk.intin, ptr, anz*2);
  50.     vdi(&VDI_pb);
  51.     w = _VDIParBlk.ptsout[2] - _VDIParBlk.ptsout[0];
  52.     return w;
  53. }
  54.  
  55. /* Liefert die interne Position */
  56. WORD InterPos(WORD x, LINEP a, BOOLEAN tab, WORD tab_size)
  57. {
  58.     WORD    len  = 0,
  59.             tabH = tab_size,
  60.              i    = 0;
  61.     UBYTE *str, t;
  62.  
  63.     if (!tab)
  64.         return min(x,a->len);
  65.     str = TEXT(a);
  66.     t = '\t';
  67.     while(len<x && i<a->len)
  68.     {
  69.         if ((*str++)==t)
  70.         {
  71.             len += tabH;
  72.             tabH = tab_size;
  73.         }
  74.         else
  75.         {
  76.             len++;
  77.             if ((--tabH)==0)
  78.                 tabH = tab_size;
  79.         }
  80.         i++;
  81.     }
  82.     if (len > x)
  83.         i--;
  84.     return i;
  85. }
  86.  
  87. WORD BildLen(LINEP a, BOOLEAN tab, WORD tab_size)
  88. {
  89.     return BildPos(a->len,a,tab,tab_size);
  90. }
  91.  
  92. WORD BildPos(WORD x, LINEP a, BOOLEAN tab, WORD tab_size)
  93. {
  94.     WORD    len  = 0,
  95.             tabH = tab_size;
  96.     UBYTE    *str, t;
  97.  
  98.     if (x>a->len)
  99.         x = a->len;
  100.     if (!tab)
  101.         return x;
  102.     t = '\t';
  103.     str = TEXT(a);
  104.     while ((--x)>=0)
  105.     {
  106.         if ((*str++)==t)
  107.         {
  108.             len += tabH;
  109.             tabH = tab_size;
  110.         }
  111.         else
  112.         {
  113.             len++;
  114.             if ((--tabH)==0)
  115.                 tabH = tab_size;
  116.         }
  117.     }
  118.     return len;
  119. }
  120.  
  121. WORD cursor_xpos(TEXTP t_ptr, WORD pos)
  122. {
  123.     WORD    len;
  124.  
  125.     tab = t_ptr->loc_opt->tab;
  126.     tab_size = t_ptr->loc_opt->tabsize;
  127.     umbrechen = t_ptr->loc_opt->umbrechen;
  128.     show_end = t_ptr->loc_opt->show_end;
  129.     if (winFont.prop)
  130.     {
  131.         w_line_to_str(t_ptr->cursor_line, w_text);
  132.         len = BildPos(pos, t_ptr->cursor_line, tab, tab_size);
  133.         len = Vqt_extent(w_text, len);
  134.     }
  135.     else
  136.         len = BildPos(pos, t_ptr->cursor_line, tab, tab_size)*gl_wchar;
  137.     return len;
  138. }
  139.  
  140. LOCAL VOID _cursor(WINDOWP window, WORD xpos, LONG ypos, WORD w, WORD h)
  141. {
  142.     WORD     pxy[4];
  143.  
  144.     /* ACHTUNG: xpos in Pixeln, ypos in Zeilen!! */
  145.  
  146.     if (xpos >= 0 && xpos < window->work.w &&
  147.         ypos >= 0 && ypos < window->w_hight)
  148.     {
  149.         pxy[0] = xpos + window->work.x;
  150.         pxy[1] = (short) ypos * h + window->work.y;
  151.         pxy[2] = pxy[0] + w;
  152.         pxy[3] = pxy[1] + (h - 1);
  153.         if (ypos > 0)
  154.             pxy[1] -= 2;
  155.         if (ypos < window->w_hight-1)
  156.             pxy[3] += 2;
  157.         vswr_mode(vdi_handle, MD_XOR);
  158.         if (fill_color!=BLACK)
  159.         {
  160.             vsf_color(vdi_handle, BLACK);
  161.             fill_color = BLACK;
  162.         }
  163.         vr_recfl (vdi_handle, pxy);
  164.         vswr_mode(vdi_handle, MD_REPLACE);
  165.     }
  166. }
  167.  
  168. VOID cursor(WINDOWP window, TEXTP t_ptr)
  169. {
  170.     WORD    xpos, breite, hoehe, pxy[8];
  171.     LONG    ypos;
  172.     UBYTE    c[2];
  173.  
  174.     wind_update(BEG_UPDATE);
  175.     Hide_mouse();
  176.  
  177.     if (overwrite)
  178.     {
  179.         if (winFont.prop)
  180.         {
  181.             strncpy(c, TEXT(t_ptr->cursor_line) + t_ptr->xpos, 1);
  182.             c[1] = EOS;
  183.             vqt_extent(vdi_handle, c, pxy);
  184.             breite = pxy[2] - pxy[0];
  185.             breite = breite ? breite : 1;
  186.             hoehe = pxy[7] - pxy[1];
  187.         }
  188.         else
  189.         {
  190.             breite = gl_wchar;
  191.             hoehe = gl_hchar;
  192.         }
  193.     }
  194.     else
  195.     {
  196.         breite = 2;
  197.         hoehe = gl_hchar;
  198.     }
  199.  
  200.     ypos = t_ptr->ypos - window->doc.y;
  201.     xpos = cursor_xpos(t_ptr, t_ptr->xpos) - ((short) window->doc.x * gl_wchar);
  202.     if (free_for_draw(window))
  203.     {
  204.         set_clip(FALSE,NULL);
  205.         _cursor(window, xpos, ypos, breite, hoehe);
  206.     }
  207.     else
  208.     {
  209.         RECT    a, b;
  210.  
  211.         a.x = xpos + window->work.x;
  212.         a.y = (short) ypos * hoehe + window->work.y;
  213.         a.w = breite + 1;
  214.         a.h = hoehe + 1;
  215.         if (ypos > 0)
  216.         {
  217.             a.y -= 2;
  218.             a.h += 2;
  219.         }
  220.         if (ypos < window->w_hight-1)
  221.             a.h += 2;
  222.         if (rc_first(window->handle, &a, &b))
  223.         {
  224.             do
  225.             {
  226.                 set_clip(TRUE, &b);
  227.                 _cursor(window, xpos, ypos, breite, hoehe);
  228.             }
  229.             while(rc_next(window->handle, &b));
  230.         }
  231.     }
  232.     Show_mouse();
  233.     wind_update(END_UPDATE);
  234. }
  235.  
  236. LOCAL LINEP get_wline(TEXTP t_ptr, LONG y)
  237. {
  238.     LINEP lauf;
  239.     LONG     i;
  240.  
  241.     if (y<0 || y>=t_ptr->text.lines)
  242.         return NULL;
  243.     i = t_ptr->ypos;
  244.     lauf = t_ptr->cursor_line;
  245.     if (i>y)
  246.     {
  247.         i -= y;
  248.         while (TRUE)
  249.         {
  250.             VORG(lauf);
  251.             if ((--i)==0)
  252.                 break;
  253.             VORG(lauf);
  254.             if ((--i)==0)
  255.                 break;
  256.             VORG(lauf);
  257.             if ((--i)==0)
  258.                 break;
  259.             VORG(lauf);
  260.             if ((--i)==0)
  261.                 break;
  262.         }
  263.     }
  264.     else if (i<y)
  265.     {
  266.         y -= i;
  267.         while (TRUE)
  268.         {
  269.             NEXT(lauf);
  270.             if ((--y)==0)
  271.                 break;
  272.             NEXT(lauf);
  273.             if ((--y)==0)
  274.                 break;
  275.             NEXT(lauf);
  276.             if ((--y)==0)
  277.                 break;
  278.             NEXT(lauf);
  279.             if ((--y)==0)
  280.                 break;
  281.         }
  282.     }
  283.     return (lauf);
  284. }
  285.  
  286. LOCAL WORD w_line_to_str(LINEP a, WORD *t)
  287. /* Expandiert eine ganze Zeile zu einem String für die Ausgabe */
  288. /* Tab-Zeichen werden u.U. in mehrere CHR(32) gewandelt            */
  289. /* Die Stringlänge wird zurückgegeben                                    */
  290. {
  291.     WORD    tabH, len, i;
  292.     UBYTE    *str;
  293.     WORD    c, t_c, s_c;
  294.  
  295.     str = TEXT(a);
  296.     s_c = ' ';
  297.     t_c = '\t';
  298.     if (tab)
  299.     {
  300.         tabH = tab_size;
  301.         for (i=a->len,len=256; (--i)>=0; )
  302.         {
  303.             c = *str++;
  304.             if (c==t_c)
  305.             {
  306.                 len -= tabH;
  307.                 if (len<0)
  308.                 {
  309.                     tabH += len;
  310.                     len = 0;
  311.                 }
  312.                 while (TRUE)
  313.                 {
  314.                     *t++ = s_c;
  315.                     if ((--tabH)==0)
  316.                         break;
  317.                     *t++ = s_c;
  318.                     if ((--tabH)==0)
  319.                         break;
  320.                     *t++ = s_c;
  321.                     if ((--tabH)==0)
  322.                         break;
  323.                     *t++ = s_c;
  324.                     if ((--tabH)==0)
  325.                         break;
  326.                 }
  327.                 if (len==0)
  328.                     break;            /* Puffer voll */
  329.                 tabH = tab_size;
  330.             }
  331.             else if (c<min_ascii || c>max_ascii)
  332.             {
  333.                 *t++ = s_c;
  334.                 if ((--tabH)==0) tabH = tab_size;
  335.                 if ((--len)==0) break;        /* Puffer voll */
  336.             }
  337.             else
  338.             {
  339.                 *t++ = c;
  340.                 if ((--tabH)==0) tabH = tab_size;
  341.                 if ((--len)==0) break;        /* Puffer voll */
  342.             }
  343.         }
  344.         len = 256-len;
  345.     }
  346.     else
  347.     {
  348.         for (i=a->len,len=0; (--i)>=0 && (len<256); len++)
  349.         {
  350.             c = *str++;
  351.             if (c<min_ascii || c>max_ascii)
  352.                 *t++ = s_c;
  353.             else
  354.                 *t++ = c;
  355.         }
  356.     }
  357.     return(len);
  358. }
  359.  
  360. LOCAL WORD line_to_str(LINEP a, UBYTE *t)
  361. /* Expandiert eine ganze Zeile zu einem String für die Ausgabe */
  362. /* Tab-Zeichen werden ggf. in mehrere CHR(32) gewandelt            */
  363. /* Die Stringlänge wird zurückgegeben                                    */
  364. {
  365.     WORD    len, i;
  366.     UBYTE    *str, c;
  367.  
  368.     str = TEXT(a);
  369.     if (tab)
  370.     {
  371.         WORD    tabH;
  372.         UBYTE    t_c, s_c;
  373.  
  374.         t_c = '\t';
  375.         s_c = ' ';
  376.         tabH = tab_size;
  377.         for (i=a->len,len=256; (--i)>=0; )
  378.         {
  379.             c = *str++;
  380.             if (c==t_c)
  381.             {
  382.                 len -= tabH;
  383.                 if (len<0)
  384.                 {
  385.                     tabH += len;
  386.                     len = 0;
  387.                 }
  388.                 while (TRUE)
  389.                 {
  390.                     *t++ = s_c;    if ((--tabH)==0) break;
  391.                     *t++ = s_c;    if ((--tabH)==0) break;
  392.                     *t++ = s_c;    if ((--tabH)==0) break;
  393.                     *t++ = s_c;    if ((--tabH)==0) break;
  394.                 }
  395.                 if (len==0) break;            /* Puffer voll */
  396.                 tabH = tab_size;
  397.             }
  398.             else if (c<min_ascii || c>max_ascii)
  399.             {
  400.                 *t++ = s_c;
  401.                 if ((--tabH)==0) tabH = tab_size;
  402.                 if ((--len)==0) break;        /* Puffer voll */
  403.             }
  404.             else
  405.             {
  406.                 *t++ = c;
  407.                 if ((--tabH)==0) tabH = tab_size;
  408.                 if ((--len)==0) break;        /* Puffer voll */
  409.             }
  410.         }
  411.         len = 256-len;
  412.         len++;
  413.         *t = EOS;
  414.     }
  415.     else
  416.     {
  417.         for (i=a->len,len=0; (--i)>=0 && (len<256); len++)
  418.         {
  419.             c = *str++;
  420.             if (c<min_ascii || c>max_ascii)
  421.                 *t++ = ' ';
  422.             else
  423.                 *t++ = c;
  424.         }
  425.         len++;
  426.         *t = EOS;
  427.     }
  428.     return(len);
  429. }
  430.  
  431. VOID outc(WORD x, WORD y, WORD w)
  432. /* x ist Pixel-Koordinate                                                */
  433. /* y ist Pixel-Koordinate                                                */
  434. /* w ist die Breite in Pixel, die abgedeckt werden soll        */
  435. {
  436.     WORD    pxy[4];
  437.  
  438.     if (w<=0) return;
  439.     pxy[0] = x;
  440.     pxy[1] = y;
  441.     pxy[2] = w+x-1;
  442.     pxy[3] = y+gl_hchar-1;
  443.     if (fill_color!=WHITE)
  444.     {
  445.         vsf_color(vdi_handle,WHITE);
  446.         fill_color = WHITE;
  447.     }
  448.     vr_recfl (vdi_handle, pxy);                /* Bereich löschen */
  449. }
  450.  
  451. VOID outcB(WORD x, WORD y, WORD w)
  452. /* x ist Pixel-Koordinate                                                */
  453. /* y ist Pixel-Koordinate                                                */
  454. /* w ist die Breite in Pixel, die abgedeckt werden soll        */
  455. {
  456.     WORD    pxy[4];
  457.  
  458.     if (w<=0) return;
  459.     pxy[0] = x;
  460.     pxy[1] = y;
  461.     pxy[2] = w+x-1;
  462.     pxy[3] = y+gl_hchar-1;
  463.     if (fill_color!=BLACK)
  464.     {
  465.         vsf_color(vdi_handle,BLACK);
  466.         fill_color = BLACK;
  467.     }
  468.     vr_recfl (vdi_handle, pxy);                /* Bereich löschen */
  469. }
  470.  
  471. WORD outs(WORD x, WORD y, WORD w, CONST UBYTE *str)
  472. /* x ist Pixel-Koordinate                                                */
  473. /* y ist Pixel-Koordinate                                                */
  474. /* w ist die Breite in Pixel, die abgedeckt werden soll        */
  475. /* return ende der Textausgabe                                        */
  476. {
  477.     WORD    pxy[8], len;
  478.  
  479.     if (w <= 0)
  480.         return x;
  481.     v_gtext(vdi_handle, x, y, (UBYTE*)str);
  482.     if (winFont.prop)
  483.     {
  484.         vqt_extent(vdi_handle,(UBYTE*)str,pxy);
  485.         len = pxy[2]-pxy[0];
  486.     }
  487.     else
  488.         len = (short) strlen(str) * gl_wchar;
  489.     if (len<w)
  490.     {
  491.         pxy[0] = len+x;
  492.         pxy[1] = y;
  493.         pxy[2] = x+w-1;
  494.         pxy[3] = y+gl_hchar-1;
  495.         if (fill_color!=WHITE)
  496.         {
  497.             vsf_color(vdi_handle,WHITE);
  498.             fill_color = WHITE;
  499.         }
  500.         vr_recfl (vdi_handle, pxy);                /* Bereich löschen */
  501.         return x+len;
  502.     }
  503.     return x+w;
  504. }
  505.  
  506. WORD outsB(WORD x, WORD y, WORD w, CONST UBYTE *str)
  507. /* x ist Pixel-Koordinate                                                */
  508. /* y ist Pixel-Koordinate                                                */
  509. /* w ist die Breite in Pixel, die abgedeckt werden soll        */
  510. /* return ende der Textausgabe                                        */
  511. {
  512.     WORD    pxy[8], len;
  513.  
  514.     if (w <= 0)
  515.         return x;
  516.  
  517.     pxy[0] = x;
  518.     pxy[1] = y;
  519.     pxy[2] = x+ w -1;
  520.     pxy[3] = y+ gl_hchar -1;
  521.     if (fill_color!=BLACK)
  522.     {
  523.         vsf_color(vdi_handle,BLACK);
  524.         fill_color = BLACK;
  525.     }
  526.     vr_recfl(vdi_handle, pxy);
  527.     vswr_mode(vdi_handle, MD_XOR);
  528.     v_gtext(vdi_handle, x, y, (UBYTE*)str);
  529.     vswr_mode(vdi_handle, MD_REPLACE);
  530.     if (winFont.prop)
  531.     {
  532.         vqt_extent(vdi_handle,(UBYTE*)str,pxy);
  533.         len = pxy[2]-pxy[0];
  534.     }
  535.     else
  536.         len = (short) strlen(str) * gl_wchar;
  537.     if (len > w)
  538.         return x+w;
  539.     return x+len;
  540. }
  541.  
  542. LOCAL VOID draw_cr(WORD x, WORD y)
  543. {
  544.     WORD pxy[6], h, b;
  545.  
  546.     b = min(gl_wchar,gl_hchar);
  547.     h = b>>1;
  548.     y += (gl_hchar>>1);
  549.     pxy[0] = x+b-1;                /* oben rechts */
  550.     pxy[1] = y-h;
  551.     pxy[2] = x+b-1;                /* mitte rechst */
  552.     pxy[3] = y;
  553.     pxy[4] = x;                        /* mitte links */
  554.     pxy[5] = y;
  555.     v_pline (vdi_handle, 3, pxy);
  556.     h = h>>1;
  557.     pxy[0] = x+h;                    /* schräg oben */
  558.     pxy[1] = y-h;
  559.     pxy[2] = x;                        /* mitte links */
  560.     pxy[3] = y;
  561.     pxy[4] = x+h;                    /* schräg unten */
  562.     pxy[5] = y+h;
  563.     v_pline (vdi_handle, 3, pxy);
  564. }
  565.  
  566. LOCAL VOID draw_crB(WORD x, WORD y)
  567. {
  568.     WORD pxy[6], h, b;
  569.  
  570.     vsl_color (vdi_handle, WHITE);
  571.     b = min(gl_wchar,gl_hchar);
  572.     h = b>>1;
  573.     y += (gl_hchar>>1);
  574.     pxy[0] = x+b-1;                /* oben rechts */
  575.     pxy[1] = y-h;
  576.     pxy[2] = x+b-1;                /* mitte rechst */
  577.     pxy[3] = y;
  578.     pxy[4] = x;                        /* mitte links */
  579.     pxy[5] = y;
  580.     v_pline (vdi_handle, 3, pxy);
  581.     h = h>>1;
  582.     pxy[0] = x+h;                    /* schräg oben */
  583.     pxy[1] = y-h;
  584.     pxy[2] = x;                        /* mitte links */
  585.     pxy[3] = y;
  586.     pxy[4] = x+h;                    /* schräg unten */
  587.     pxy[5] = y+h;
  588.     v_pline (vdi_handle, 3, pxy);
  589.     vsl_color (vdi_handle, BLACK);
  590. }
  591.  
  592. LOCAL VOID str_out(WORD x, WORD y, WORD w, WORD offset, LINEP a)
  593. /* x ist Pixel-Koordinate                                                */
  594. /* y ist Pixel-Koordinate                                                */
  595. /* w ist die Breite in Pixel, die abgedeckt werden soll        */
  596. /* offset in Zeichen                                                        */
  597. {
  598.     WORD    len, anz;
  599.     WORD    pxy[4];
  600.  
  601.     anz = w_line_to_str(a, w_text);
  602.     if (winFont.prop)
  603.     {
  604.         offset *= gl_wchar;
  605.         x -= offset;
  606.         w += offset;
  607.  
  608.         V_gtext(x, y, w_text, anz);
  609.         len = Vqt_extent(w_text,anz);
  610.         if (len<w)
  611.         {
  612.             pxy[0] = x+len;
  613.             pxy[1] = y;
  614.             pxy[2] = x+w-1;
  615.             pxy[3] = y+gl_hchar-1;
  616.             if (fill_color!=WHITE)
  617.             {
  618.                 vsf_color(vdi_handle,WHITE);
  619.                 fill_color = WHITE;
  620.             }
  621.             vr_recfl (vdi_handle, pxy);                /* Bereich löschen */
  622.             if (umbrechen && (a->info&ABSATZ) && show_end)
  623.                 draw_cr(x+len,y);
  624.         }
  625.     }
  626.     else
  627.     {
  628.         if (offset>=anz)
  629.         {
  630.             outc(x,y,w);
  631.             if (offset==anz && umbrechen && (a->info&ABSATZ) && show_end)
  632.                 draw_cr(x,y);
  633.         }
  634.         else
  635.         {
  636.             anz -= offset;
  637.             len = anz*gl_wchar;
  638.             if (w<=len)
  639.             {
  640.                 V_gtext(x, y, w_text+offset, w/gl_wchar);
  641.             }
  642.             else
  643.             {
  644.                 V_gtext(x, y, w_text+offset, anz);
  645.                 pxy[0] = x+len;
  646.                 pxy[1] = y;
  647.                 pxy[2] = x+w-1;
  648.                 pxy[3] = y+gl_hchar-1;
  649.                 if (fill_color!=WHITE)
  650.                 {
  651.                     vsf_color(vdi_handle,WHITE);
  652.                     fill_color = WHITE;
  653.                 }
  654.                 vr_recfl (vdi_handle, pxy);                /* Bereich löschen */
  655.                 if (umbrechen && (a->info&ABSATZ) && show_end)
  656.                     draw_cr(x+len,y);
  657.             }
  658.         }
  659.     }
  660. }
  661.  
  662. LOCAL VOID str_outB(WORD x, WORD y, WORD w, WORD offset, LINEP a, WORD mode, WORD x1, WORD x2)
  663. /* x ist Pixel-Koordinate                                                */
  664. /* y ist Pixel-Koordinate                                                */
  665. /* w ist die Breite in Pixel, die abgedeckt werden soll        */
  666. /* offset in Zeichen                                                        */
  667. /* mode (BLKANF, BLKEND, BLKFULL)                           */
  668. {
  669.     WORD    anz, anz1, anz2, len, len2, pxy[8], end;
  670.     UBYTE    h;
  671.  
  672.     anz = line_to_str(a, text);
  673.     if (anz <= offset)        /* ganze Zeile weiss oder schwarz ohne Text */
  674.     {
  675.         if (winFont.prop)
  676.         {
  677.             vqt_extent(vdi_handle,text,pxy);
  678.             end = x-(offset*gl_wchar)+(pxy[2]-pxy[0]);
  679.         }
  680.         else
  681.             end = x-(offset*gl_wchar)+anz*gl_wchar;
  682.         if (mode == BLKFULL || mode == BLKANF)
  683.         {
  684.             outcB(x,y,w);
  685.             if (end >= x && end < x+w && umbrechen && (a->info & ABSATZ) && show_end)
  686.                 draw_crB(end,y);
  687.         }
  688.         else
  689.         {
  690.             outc(x,y,w);
  691.             if (end>=x && end<x+w && umbrechen && (a->info&ABSATZ) && show_end)
  692.                 draw_cr(end,y);
  693.         }
  694.         return;
  695.     }
  696.     if (winFont.prop)
  697.     {
  698.         offset *= gl_wchar;
  699.         x -= offset;
  700.         w += offset;
  701.         if (mode==BLKFULL)
  702.         /* Ganze Zeile einheitlich invers */
  703.         {
  704.             end = outsB(x,y,w,text);
  705.             if (end<x+w && umbrechen && (a->info&ABSATZ) && show_end)
  706.                 draw_crB(end,y);
  707.         }
  708.         else
  709.         /* Blockanfang oder -ende oder beides */
  710.         {
  711.             if (mode==BLKANF)
  712.             {
  713.                 anz1 = BildPos(x1,a,tab,tab_size);
  714.                 h = text[anz1]; text[anz1] = EOS;
  715.                 vqt_extent(vdi_handle,text,pxy);
  716.                 len = pxy[2]-pxy[0];
  717.                 end = outs(x,y,len,text);
  718.                 text[anz1] = h;
  719.                 end = outsB(end,y,w-len,text+anz1);
  720.                 if (end<x+w && umbrechen && (a->info&ABSATZ) && show_end)
  721.                     draw_crB(end,y);
  722.             }
  723.             else if (mode==BLKEND)
  724.             {
  725.                 anz1 = BildPos(x2,a,tab,tab_size);
  726.                 h = text[anz1]; text[anz1] = EOS;
  727.                 vqt_extent(vdi_handle,text,pxy);
  728.                 len = pxy[2]-pxy[0];
  729.                 end = outsB(x,y,len,text);
  730.                 text[anz1] = h;
  731.                 end = outs(end,y,w-len,text+anz1);
  732.                 if (end<x+w && umbrechen && (a->info&ABSATZ) && show_end)
  733.                     draw_cr(end,y);
  734.             }
  735.             else /* (mode==(BLKANF+BLKEND) */
  736.             {
  737.                 anz1 = BildPos(x1,a,tab,tab_size);
  738.                 h = text[anz1]; text[anz1] = EOS;
  739.                 vqt_extent(vdi_handle,text,pxy);
  740.                 len = pxy[2]-pxy[0];
  741.                 end = outs(x,y,len,text);
  742.                 text[anz1] = h;
  743.  
  744.                 anz2 = BildPos(x2,a,tab,tab_size);
  745.                 h = text[anz2]; text[anz2] = EOS;
  746.                 vqt_extent(vdi_handle,text+anz1,pxy);
  747.                 len2 = pxy[2]-pxy[0];
  748.                 end = outsB(end,y,len2,text+anz1);
  749.                 text[anz2] = h;
  750.  
  751.                 end = outs(end,y,w-len-len2,text+anz2);
  752.                 if (end < x+w && umbrechen && (a->info & ABSATZ) && show_end)
  753.                     draw_cr(end,y);
  754.             }
  755.         }
  756.     }
  757.     else
  758.     {
  759.         UBYTE *ptr = text+offset;
  760.  
  761.         anz -= offset;
  762.         if (anz * gl_wchar > w)
  763.         {
  764.             anz = w/gl_wchar;
  765.             ptr[anz] = EOS;
  766.         }
  767.         if (mode == BLKFULL)
  768.         /* Ganze Zeile einheitlich invers */
  769.         {
  770.             end = outsB(x,y,w,ptr);
  771.             if (end < x+w && umbrechen && (a->info & ABSATZ) && show_end)
  772.                 draw_crB(end, y);
  773.         }
  774.         else
  775.         /* Blockanfang oder -ende oder beides */
  776.         {
  777.             if (mode==BLKANF)
  778.             {
  779.                 anz1 = BildPos(x1,a,tab,tab_size)-offset;
  780.                 if (anz1<0) anz1 = 0;
  781.                 if (anz1>anz) anz1 = anz;
  782.                 h = ptr[anz1]; ptr[anz1] = EOS;
  783.                 len = anz1*gl_wchar;
  784.                 end = outs(x,y,len,ptr);
  785.                 ptr[anz1] = h;
  786.                 end = outsB(end,y,w-len,ptr+anz1);
  787.  
  788.                 if (end<x+w && umbrechen && (a->info&ABSATZ) && show_end)
  789.                     draw_crB(end,y);
  790.             }
  791.             else if (mode==BLKEND)
  792.             {
  793.                 anz1 = BildPos(x2,a,tab,tab_size)-offset;
  794.                 if (anz1<0) anz1 = 0;
  795.                 if (anz1>anz) anz1 = anz;
  796.                 h = ptr[anz1]; ptr[anz1] = EOS;
  797.                 len = anz1*gl_wchar;
  798.                 end = outsB(x,y,len,ptr);
  799.                 ptr[anz1] = h;
  800.                 end = outs(end,y,w-len,ptr+anz1);
  801.                 if (end<x+w && umbrechen && (a->info&ABSATZ) && show_end)
  802.                     draw_cr(end,y);
  803.             }
  804.             else /* (mode==(BLKANF+BLKEND) */
  805.             {
  806.                 anz1 = BildPos(x1,a,tab,tab_size)-offset;
  807.                 if (anz1<0) anz1 = 0;
  808.                 if (anz1>anz) anz1 = anz;
  809.                 h = ptr[anz1]; ptr[anz1] = EOS;
  810.                 len = anz1*gl_wchar;
  811.                 end = outs(x,y,len,ptr);
  812.                 ptr[anz1] = h;
  813.  
  814.                 anz2 = BildPos(x2,a,tab,tab_size)-offset;
  815.                 if (anz2<0) anz2 = 0;
  816.                 if (anz2>anz) anz2 = anz;
  817.                 h = ptr[anz2]; ptr[anz2] = EOS;
  818.                 len2  = anz2*gl_wchar - len;
  819.                 end = outsB(end,y,len2,ptr+anz1);
  820.                 ptr[anz2] = h;
  821.  
  822.                 end = outs(end,y,w-len-len2,ptr+anz2);
  823.                 if (end<x+w && umbrechen && (a->info&ABSATZ) && show_end)
  824.                     draw_cr(end,y);
  825.             }
  826.         }
  827.     }
  828. }
  829.  
  830. /* =========================================================== */
  831.  
  832. VOID line_out(WINDOWP window, TEXTP t_ptr, WORD wy)
  833. {
  834.     WORD    y;
  835.     LINEP col;
  836.     RECT    c;
  837.  
  838.     tab = t_ptr->loc_opt->tab;
  839.     tab_size = t_ptr->loc_opt->tabsize;
  840.     umbrechen = t_ptr->loc_opt->umbrechen;
  841.     show_end = t_ptr->loc_opt->show_end;
  842.     if (winFont.prop)
  843.     {
  844.         if (!get_clip(&c))
  845.             set_clip(TRUE,&window->work);
  846.         else
  847.         {
  848.             myrc_intersect(&window->work,&c);
  849.             set_clip(TRUE,&c);
  850.         }
  851.     }
  852.     y = window->work.y+wy*gl_hchar;
  853.     col = get_wline(t_ptr, window->doc.y+wy);
  854.     if (col!=NULL)        /* Kommt vor */
  855.     {
  856.         if (t_ptr->block)
  857.         {
  858.             wy += (short) window->doc.y;
  859.             if (wy<t_ptr->z1 || wy>t_ptr->z2)
  860.                 str_out(window->work.x, y, window->work.w, (short)window->doc.x, col);
  861.             else
  862.             {
  863.                 WORD    mode = 0;
  864.  
  865.                 if (wy == t_ptr->z1)
  866.                     mode |= BLKANF;
  867.                 if (wy == t_ptr->z2)
  868.                     mode |= BLKEND;
  869.                 if (!mode)
  870.                     mode = BLKFULL;
  871.                 str_outB(window->work.x, y, window->work.w,
  872.                          (short) window->doc.x, col, mode, t_ptr->x1, t_ptr->x2);
  873.             }
  874.         }
  875.         else
  876.             str_out(window->work.x, y, window->work.w, (short) window->doc.x, col);
  877.     }
  878.     else
  879.         outc(window->work.x, y, window->work.w);
  880. }
  881.  
  882. VOID bild_out(WINDOWP window, TEXTP t_ptr)
  883. {
  884.     WORD    x, y, w, xy[4];
  885.     LINEP lauf;
  886.     WORD    MIN_COL, MAX_COL, MAX_Y;
  887.     RECT    c;
  888.  
  889.     tab = t_ptr->loc_opt->tab;
  890.     tab_size = t_ptr->loc_opt->tabsize;
  891.     umbrechen = t_ptr->loc_opt->umbrechen;
  892.     show_end = t_ptr->loc_opt->show_end;
  893.     x = window->work.x;
  894.     y = window->work.y;
  895.     w = window->work.w;
  896.  
  897.     if (window->class == CLASS_EDIT)                        /* Kopf ausgeben */
  898.         head_out(window, t_ptr);
  899.  
  900.     MIN_COL = 0;
  901.     MAX_COL = (short) min(window->w_hight - 1, t_ptr->text.lines - window->doc.y-1);
  902.     MAX_Y   = y + window->work.h-1;
  903.     if (get_clip(&c))                    /* nicht alles malen */
  904.     {
  905.         WORD y2 = c.y-y;
  906.  
  907.         MIN_COL = max(MIN_COL,y2/gl_hchar);
  908.         MAX_COL = min(MAX_COL, (c.y+c.h-1)/gl_hchar);
  909.         MAX_Y = min(MAX_Y, c.y+c.h-1);
  910.     }
  911.  
  912.     if (winFont.prop)
  913.     {
  914.         if (!get_clip(&c))
  915.             set_clip(TRUE,&window->work);
  916.         else
  917.         {
  918.             myrc_intersect(&window->work,&c);
  919.             set_clip(TRUE,&c);
  920.         }
  921.     }
  922.  
  923.     y += (MIN_COL*gl_hchar);
  924.     lauf = get_wline(t_ptr, window->doc.y+MIN_COL);
  925.     if (lauf!=NULL)
  926.     {
  927.         WORD    xoffset, i;
  928.  
  929.         xoffset = (short) window->doc.x;
  930.         if (t_ptr->block)
  931.         {
  932.             LONG    y_r;
  933.  
  934.             y_r = window->doc.y+MIN_COL;
  935.             for (i=MIN_COL ; i<=MAX_COL; y_r++,y+=gl_hchar,NEXT(lauf),i++)
  936.             {
  937.                 /* Block nicht sichtbar */
  938.                 if (y_r < t_ptr->z1 || y_r > t_ptr->z2)
  939.                     str_out(x, y, w, xoffset, lauf);
  940.                 else
  941.                 {
  942.                     WORD mode = 0;
  943.  
  944.                     if (y_r == t_ptr->z1)
  945.                         mode |= BLKANF;
  946.                     if (y_r == t_ptr->z2)
  947.                         mode |= BLKEND;
  948.                     if (!mode)
  949.                         mode = BLKFULL;
  950.                     str_outB(x, y, w, xoffset, lauf, mode, t_ptr->x1, t_ptr->x2);
  951.                 }
  952.             }
  953.         }
  954.         else
  955.         {
  956.             for (i=MIN_COL ; i<=MAX_COL; y+=gl_hchar,NEXT(lauf),i++)
  957.  
  958.                 str_out(x,y,w,xoffset,lauf);
  959.         }
  960.     }
  961.     if (y<MAX_Y)
  962.     {
  963.         xy[0] = x;
  964.         xy[1] = y;
  965.         xy[2] = x+w-1;
  966.         xy[3] = MAX_Y;
  967.         if (fill_color!=WHITE)
  968.         {
  969.             vsf_color(vdi_handle,WHITE);
  970.             fill_color = WHITE;
  971.         }
  972.         vr_recfl (vdi_handle, xy);                            /* Bereich löschen */
  973.     }
  974. }
  975.  
  976. VOID bild_blkout(WINDOWP window, TEXTP t_ptr, LONG z1, LONG z2)
  977. /* Alle Textzeilen zwischen z1 und z2 werden neu ausgegeben */
  978. {
  979.     WORD    i, x, y, w, xoffset;
  980.     LINEP lauf;
  981.     WORD    MAX_COL;
  982.     LONG    lines, y_r;
  983.     RECT    c;
  984.  
  985.     tab = t_ptr->loc_opt->tab;
  986.     tab_size = t_ptr->loc_opt->tabsize;
  987.     umbrechen = t_ptr->loc_opt->umbrechen;
  988.     show_end = t_ptr->loc_opt->show_end;
  989.     if (z1>z2)
  990.     {
  991.         lines = z1;
  992.         z1 = z2;
  993.         z2 = lines;
  994.     }
  995.     if (winFont.prop)
  996.     {
  997.         if (!get_clip(&c))
  998.             set_clip(TRUE,&window->work);
  999.         else
  1000.         {
  1001.             myrc_intersect(&window->work,&c);
  1002.             set_clip(TRUE,&c);
  1003.         }
  1004.     }
  1005.  
  1006.     x          = window->work.x;
  1007.     y           = window->work.y;
  1008.  
  1009.     w          = window->work.w;
  1010.     xoffset = (short) window->doc.x;
  1011.     MAX_COL = (short) min(window->w_hight-1, t_ptr->text.lines-window->doc.y-1);
  1012.     y_r      = window->doc.y;
  1013.     lauf = get_wline(t_ptr, y_r);
  1014.  
  1015.     if (t_ptr->block)
  1016.         for (i=0; i<=MAX_COL; i++,y+=gl_hchar,y_r++)
  1017.         {
  1018.             if (y_r>=z1 && y_r<=z2)
  1019.             {
  1020.                 if (y_r<t_ptr->z1 || y_r>t_ptr->z2)
  1021.                     str_out(x,y,w,xoffset,lauf);
  1022.                 else
  1023.                 {
  1024.                     WORD mode = 0;
  1025.  
  1026.                     if (y_r==t_ptr->z1) mode |= BLKANF;
  1027.                     if (y_r==t_ptr->z2) mode |= BLKEND;
  1028.                     if (!mode) mode = BLKFULL;
  1029.                     str_outB(x,y,w,xoffset,lauf,mode,t_ptr->x1,t_ptr->x2);
  1030.                 }
  1031.             }
  1032.             NEXT(lauf);
  1033.         }
  1034.     else
  1035.         for (i=0; i<=MAX_COL; i++,y+=gl_hchar,y_r++)
  1036.         {
  1037.             if (y_r>=z1 && y_r<=z2)
  1038.                 str_out(x,y,w,xoffset,lauf);
  1039.             NEXT(lauf);
  1040.         }
  1041. }
  1042.  
  1043.  
  1044. /***************************************************************************/
  1045.  
  1046. VOID head_out(WINDOWP window, TEXTP t_ptr)
  1047. {
  1048.     UBYTE    head_str[WINSTRLEN];
  1049.     WORD    len, head_len;
  1050.  
  1051.     if (t_ptr->info_str[0] != EOS)
  1052.     {
  1053.         strcpy(head_str, t_ptr->info_str);
  1054.         head_len = (short) strlen(head_str);
  1055.     }
  1056.     else
  1057.     {
  1058.         head_len = (short) strlen(STRING(HEADSTR));
  1059.         COPYB(head_str, STRING(HEADSTR), head_len + 1);
  1060.         if (t_ptr->readonly)
  1061.             head_str[1] = '\x7F';
  1062.  
  1063.         switch (t_ptr->ending)
  1064.         {
  1065.             case tos :
  1066.                 break;
  1067.             case unix :
  1068.                 head_str[2] = 'U';
  1069.                 break;
  1070.             case apple :
  1071.                 head_str[2] = 'A';
  1072.                 break;
  1073.             default:
  1074.                 head_str[2] = '?';
  1075.         }
  1076.  
  1077.         ltoa(t_ptr->ypos+1, head_str + 8, 10);
  1078.         head_str[strlen(head_str)] = ' ';
  1079.         itoa(BildPos(t_ptr->xpos,t_ptr->cursor_line,tab,tab_size)+1,head_str+18,10);
  1080.         head_str[strlen(head_str)] = ' ';
  1081.     }
  1082.     len = window->work.w / sys_wchar;
  1083.     if (len < head_len)
  1084.         head_str[len] = EOS;
  1085.     set_winfo(window, head_str);
  1086. }
  1087.  
  1088. /***************************************************************************/
  1089.